﻿// 0908train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <deque>

using namespace std;


/*
一个人设定一组四码的数字作为谜底，另一方猜。
每猜一个数，出数者就要根据这个数字给出提示，提示以XAYB形式呈现，直到猜中为止。
其中X表示位置正确的数的个数(数字正确且位置正确)，而Y表示数字正确而位置不对的数的个数。

例如，当谜底为8123，而猜谜者猜1052时，出题者必须提示0A2B.
例如，当谜底为5637，而猜谜者猜4931时，出题者必须提示1A0B.
当前已知N组猜谜者猜的数字与提示，如果答案确定，请输出答案，不确定则输出NA

输入描述
第一行输入一个正整数，0 < N < 100.
接下来N行，每一行包含一个猜测的数字与提示结果。

输出描述
输出最后的答案，答案不确定则输出NA

输入
6
4815 1A1B
5716 0A1B
7842 0A1B
4901 0A0B
8585 3A0B
8555 2A1B
输出
3585
 */
class Solution02
{
public:
    bool isChecked(string&verify_str, vector<vector<string>>& num_status_vec)
    {
        for (auto&str_vec: num_status_vec)
        {
            string status_str = str_vec[1];

            int pos_correct = status_str[0] - '0';
            int num_correct = status_str[2] - '0';

            string exec_str = str_vec[0];

            //verify_str去建表
            unordered_set<char>verify_set;
            for (auto&num_char: verify_str)
            {
                verify_set.insert(num_char);
            }

            int curr_pos_count = 0;

            //把位置正确的几个字符踢出去，再走一轮
            for (int i=0; i<4; i++)
            {
	            if (verify_str[i]==exec_str[i])
	            {
                    curr_pos_count += 1;
                    //踢出位置正确的字符
                    verify_set.erase(exec_str[i]);
	            }
            }

            int curr_num_count = 0;
            for (int i = 0; i < 4; i++)
            {
                if (verify_str[i] != exec_str[i] && verify_set.count(exec_str[i])>0)
                {
                    curr_num_count += 1;
                }
            }

            if (curr_pos_count != pos_correct || curr_num_count != num_correct)
                return false;
        }
        return true;
    }

    void solve02(vector<vector<string>>& num_status_vec)
    {
        //vector<int> 0数字 1位置正确且数字正确 2位置错误数字正确
        //位置正确就是curr[i]==curr[j]
        //数字正确就是map.count(char)>0
        vector<string>total_num_vec;

        //0000 - 9999
        for (int i = 0; i <= 9999; i++)
        {
            string i_str = to_string(i);
            if (i < 10)
            {
                i_str = "000" + i_str;
            }
            else if (i < 100)
            {
                i_str = "00" + i_str;
            }
            else if (i < 1000)
            {
                i_str = "0" + i_str;
            }
            total_num_vec.push_back(i_str);
        }

        vector<string>result;
        for (int i = 0; i < total_num_vec.size(); i++)
        {
            string curr_str = total_num_vec[i];
            bool is_checked = isChecked(curr_str, num_status_vec);

            if (is_checked)
            {
                result.push_back(curr_str);
            }
        }

        if (result.size()==1)
        {
            cout << result[0];
            return;
        }

        //请输出答案，不确定则输出NA
        cout << "NA";
        //solve02
    }

    Solution02(vector<vector<string>>& num_status_vec)
    {
        solve02(num_status_vec);
        //string num_str = "3585";
        //cout << isChecked(num_str, num_status_vec);

        //Solution01
    }
};



/*
 要求将这些货币全部换算成人民币分（fen）后进行汇总，汇总结果仅保留整数，小数部分舍弃。
元和分的换算关系都是1:100，如下：

1CNY=100fen（1元=100分）
1HKD=100cents（1港元=100港分）
1JPY=100sen（1日元=100仙）
1EUR=100eurocents（1欧元=100欧分）
1GBP=100pence（1英镑=100便士）
汇率表如下：
即：100CNY = 1825JPY = 123HKD = 14EUR = 12GBP

CNY	JPY	    HKD	EUR	GBP
100	1825	123	14	12

输入描述
第一行输入为N，N表示记录数。0<N<100
之后N行，每行表示一条货币记录，且该行只会是一种货币。

输出描述
将每行货币转换成人民币分（fen）后汇总求和，只保留整数部分。
输出格式只有整数数字，不带小数，不带单位。

输入
2
20CNY53fen
53HKD87cents

输出
6432
 */
class Solution01
{
public:
    double translateNum(double num, string kind)
    {
        //CNY	JPY	    HKD	EUR	GBP
        //100	1825	123	14	12
        if (kind =="CNY")
        {
            return num * 100;
        }
        else if (kind == "JPY")
        {
            return num / 1825 * 100 * 100;
        }
        else if (kind =="HKD")
        {
            return num / 123 * 100 * 100;
        }
        else if (kind=="EUR")
        {
            return num / 14 * 100 * 100;
        }
        else if (kind == "GBP")
        {
            return num / 12 * 100 * 100;
        }
        /*
        1CNY=100fen（1元=100分）
        1JPY=100sen（1日元=100仙）
        1HKD=100cents（1港元=100港分）
        1EUR=100eurocents（1欧元=100欧分）
        1GBP=100pence（1英镑=100便士）
         */
        else if (kind =="fen")
        {
            return num;
        }
        else if (kind == "sen")
        {
            //1JPY=100sen
            return num / 1825 * 100;
        }
        else if (kind == "cents")
        {
            //1HKD=100cents
            return num / 123 * 100;
        }
        else if (kind == "eurocents")
        {
            //1EUR=100eurocents
            return num / 14 * 100;
        }
        else if (kind == "pence")
        {
            //1GBP=100pence
            return num / 12 * 100;
        }
	    //translateNum
    }

    void computeCurr(string&str)
    {
        vector<double>num_vec;
        vector<string>kind_vec;
        double curr_num = 0;
        string kind;
        bool is_prev_num = false;
        bool is_prev_kind = false;
        for (auto& curr_char : str)
        {
            if (isdigit(curr_char))
            {
                curr_num = curr_num * 10 + curr_char - '0';
                is_prev_num = true;
                if (is_prev_kind)
                {
                    kind_vec.push_back(kind);
                    kind = "";
                    is_prev_kind = false;
                }
            }
            else
            {
                if (is_prev_num)
                {
                    num_vec.push_back(curr_num);
                    curr_num = 0;
                    is_prev_num = false;
                }
                is_prev_kind = true;
                kind += curr_char;

            }
        }
        kind_vec.push_back(kind);

        for (int i=0; i<num_vec.size(); i++)
        {
            double curr_num = num_vec[i];
            string curr_kind = kind_vec[i];

            double curr_val = translateNum(curr_num, curr_kind);

            result += curr_val;
        }

        //computeCurr
    }

    Solution01(vector<string>&origin_vec)
    {
        //num = num/汇率 * 100 * 100
        for (auto&str:origin_vec)
        {
            computeCurr(str);
        }
        cout << int(result);
	    //Solution01
    }
private:
    double result = 0;
};

int main()
{
	{
        int v_size;
        cin >> v_size;
        cin.ignore();
        vector<vector<string>>num_status_vec;

        for (int i=0; i<v_size; i++)
        {
            vector<string>min_str_v;
            string input;
            getline(cin, input);

            string token;
            stringstream oh_sstream(input);
            while (oh_sstream>>token)
            {
                min_str_v.push_back(token);
            }
            num_status_vec.push_back(min_str_v);
        }

        Solution02 solu(num_status_vec);

        return 0;
	}

/*
2
20CNY53fen
53HKD87cents
*/
    int v_size;
    cin >> v_size;
    vector<string>str_vec(v_size);
    for (int i=0; i<v_size; i++)
    {
        cin >> str_vec[i];
    }
    Solution01 solu(str_vec);

}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
